package com.tledu.data.imports.service.impl;

import com.tledu.data.imports.entity.*;
import com.tledu.data.imports.mapper.*;
import com.tledu.data.imports.util.MyDateUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.date.DateUnit;
import cn.hutool.core.util.IdUtil;
import com.tledu.data.imports.service.IAllFroms;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.sql.Timestamp;
import java.util.*;
import java.math.BigDecimal;

@Service
public class AllFromsImpl implements IAllFroms {

    @Autowired
    private TdRawWaterMapper tdRawWaterMapper;
    @Autowired
    private TdOperatingParamsTypeMapper tdOperatingParamsTypeMapper;
    @Autowired
    private TdRawWaterTypeMapper tdRawWaterTypeMapper;
    @Autowired
    private TdProcessDataTypeMapper tdProcessDataTypeMapper;
    @Autowired
    private TdProcessDataMapper tdProcessDataMapper;
    @Autowired
    private TdProductionDataMapper tdProductionDataMapper;
    @Autowired
    private TdOperatingParamsMapper tdOperatingParamsMapper;
    //存日期的集合
    List<Date> dateList = new ArrayList<>();
    //存tdRawWaterType集合
    List<TdRawWaterType> tdRawWaterTypeList = new ArrayList<>();
    //存TdRawWaterd的集合
    List<TdRawWater> tdRawWaterList = new ArrayList<>();
    //存放tdProcessDataType的集合
    List<TdProcessDataType> tdProcessDataTypeList = new ArrayList<>();
    //存放tdProcessData的集合
    List<TdProcessData> tdProcessDataList = new ArrayList<>();
    //存放tdOperatingParamsType的集合
    List<TdOperatingParamsType> tdOperatingParamsTypeList = new ArrayList<>();
    //存放tdProductionData的集合
    List<TdProductionData> tdProductionDataList = new ArrayList<>();
    //存放tdOperatingParams的集合
    List<TdOperatingParams> tdOperatingParamsList = new ArrayList<>();
    //存异常信息集合
    List<String> errorList = new ArrayList<>();
    //时间set集合
    Set<String> dateSet = new HashSet<>();
    ProjectTimeDto projectTimeDto = new ProjectTimeDto();
    Long pId;
    @Override
    public  List<String> saveExcelInfo(Map<Integer, List<LinkedHashMap>> sheetInfos) {
//        System.out.println(sheetInfos);
        dateSet.clear();
        errorList.clear();
        for (Integer sheetNo : sheetInfos.keySet()) {
            List<LinkedHashMap> maps = sheetInfos.get(sheetNo);
            // 不同sheet页数据处理方式不同
            switch (sheetNo) {
                case 0:
                    //解析第一张表
                    parsingTdRawWaterType(maps);
                    break;
                case 1:
                    parsingTdProcessDataType(maps);
                    break;
                case 2:
                    parsingTdOperatingParamsType(maps);
                    break;
                case 3:
                    parsingTdProductionData(maps);
                    break;
                default:
                    break;
            }
        }
        judgeDateSet(dateSet);
        extracted();
        return errorList;
    }
    @Override
    public void setProjectId(Long projectId){
        pId = projectId;
    }

    //解析第一张sheet表，原料水监测表
    private void parsingTdRawWaterType(List<LinkedHashMap> maps) {
        Boolean flag = true;
        String errorMessage = null;//错误信息
        errorList.clear();
        dateList.clear();
        String excelDate = "";
        int j=0;//列索引
        String[] clo = {"2","4","6","8","9","10","11","17"};//非空列的数组
        boolean index ;//判断索引
        MyDateUtil dateUtil = new MyDateUtil();

        // 从第3行开始处理（索引2），跳过前两行
        for (int i = 2; i < maps.size(); i++) {
            TdRawWater tdRawWater = new TdRawWater();
            LinkedHashMap<String, Object> row = maps.get(i);

            // 获取时间和日期字段（假设时间在 "1" 位置，日期在 "0" 位置）
            Object time = row.get("1");  // 时间字段
            Object date = row.get("0");  // 日期字段

            // 如果时间或日期为空，跳过该行
            if (time == null || date == null) {
                continue;
            }
            // 格式化日期和时间
            String formattedDateTime =dateUtil.getCurrentDate(date,time);
            //只获取日期
            String forDateTime = dateUtil.getDate(date);
            if(i==2){
                projectTimeDto.setStartTime(forDateTime);
            }
            if(forDateTime!=null){
                projectTimeDto.setEndTime(forDateTime);
            }
            excelDate = excelDate + forDateTime;

            // 将 LocalDateTime 转换为 Timestamp
            Timestamp timestamp = Timestamp.valueOf(formattedDateTime);
           // 设置拼接后的日期时间
           tdRawWater.setRecordTime(timestamp);
           Date loaclDate = tdRawWater.getRecordTime();
           tdRawWater.setProjectId(pId);
            projectTimeDto.setProjectId(pId);
           if(flag==true){
               flag = depositDate(loaclDate);
           }
            TdRawWaterType tdRawWaterType = new TdRawWaterType();;
            for (String j1:clo) {
                index=row.containsKey(j1);
                if(index==false){
                    errorMessage="原料水监测表第"+(i+2)+"行第"+(Integer.parseInt(j1)+1)+"列有空值";
                    errorList.add(errorMessage);
                }
            }
            // 2-17列的字段，类型为 zafs
            for ( j = 2; j <= 17; j++) {

                Object value = row.get(String.valueOf(j));

                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "原料水监测表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 2) tdRawWaterType.setPH((BigDecimal) value);  // 设置PH字段
                if (j == 3) tdRawWaterType.setSS((BigDecimal) value);  // 设置SS字段
                if (j == 4) tdRawWaterType.setNh3N((BigDecimal) value);  // 设置氨氮字段
                if (j == 5) tdRawWaterType.setTN((BigDecimal) value);  // 设置总氮字段
                if (j == 6) tdRawWaterType.setCOD((BigDecimal) value);  // 设置COD字段
                if (j == 7) tdRawWaterType.setBOD((BigDecimal) value);  // 设置BOD字段
                if (j == 8) tdRawWaterType.setThiocyanate((BigDecimal) value);  // 设置硫氰酸根字段
                if (j == 9) tdRawWaterType.setSulfide((BigDecimal) value);  // 设置硫化物字段
                if (j == 10) tdRawWaterType.setVolatilePhenols((BigDecimal) value);  // 设置挥发酚字段
                if (j == 11) tdRawWaterType.setALK((BigDecimal) value);  // 设置碱度字段
                if (j == 12) tdRawWaterType.setCI((BigDecimal) value);  // 设置氯离子字段
                if (j == 13) tdRawWaterType.setPetroleum((BigDecimal) value);  // 设置石油类字段
                if (j == 14) tdRawWaterType.setBenzene((BigDecimal) value);  // 设置苯字段
                if (j == 15) tdRawWaterType.setPAH((BigDecimal) value);  // 设置多环芳烃字段
                if (j == 16) tdRawWaterType.setBaP((BigDecimal) value);  // 设置苯并芘字段
                if (j == 17) tdRawWaterType.setTC((BigDecimal) value);  // 设置总氰字段

            }

            // 使用 UUID 生成唯一的 id
            long id = IdUtil.getSnowflakeNextId();
            long rawWaterId = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdRawWaterType.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id
            tdRawWaterType.setRawWaterId(rawWaterId);  // 同样处理 rawWaterId

            // 设置类型字段
            tdRawWaterType.setType("zafs");  // 根据需要设置类型
            //存对象进集合
            depositTdRawWaterType(tdRawWaterType);

            // 18-33列的字段，类型为 syas
            for ( j = 18; j <= 33; j++) {
                Object value = row.get(String.valueOf(j));

                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet1表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 18) tdRawWaterType.setPH((BigDecimal) value);  // 设置PH字段
                if (j == 19) tdRawWaterType.setSS((BigDecimal) value);  // 设置SS字段
                if (j == 20) tdRawWaterType.setNh3N((BigDecimal) value);  // 设置氨氮字段
                if (j == 21) tdRawWaterType.setTN((BigDecimal) value);  // 设置总氮字段
                if (j == 22) tdRawWaterType.setCOD((BigDecimal) value);  // 设置COD字段
                if (j == 23) tdRawWaterType.setBOD((BigDecimal) value);  // 设置BOD字段
                if (j == 24) tdRawWaterType.setThiocyanate((BigDecimal) value);  // 设置硫氰酸根字段
                if (j == 25) tdRawWaterType.setSulfide((BigDecimal) value);  // 设置硫化物字段
                if (j == 26) tdRawWaterType.setVolatilePhenols((BigDecimal) value);  // 设置挥发酚字段
                if (j == 27) tdRawWaterType.setALK((BigDecimal) value);  // 设置碱度字段
                if (j == 28) tdRawWaterType.setCI((BigDecimal) value);  // 设置氯离子字段
                if (j == 29) tdRawWaterType.setPetroleum((BigDecimal) value);  // 设置石油类字段
                if (j == 30) tdRawWaterType.setBenzene((BigDecimal) value);  // 设置苯字段
                if (j == 31) tdRawWaterType.setPAH((BigDecimal) value);  // 设置多环芳烃字段
                if (j == 32) tdRawWaterType.setBaP((BigDecimal) value);  // 设置苯并芘字段
                if (j == 33) tdRawWaterType.setTC((BigDecimal) value);  // 设置总氰字段

            }

            // 使用 UUID 生成唯一的 id
            id = IdUtil.getSnowflakeNextId();
            // 设置 id 和 rawWaterId
            tdRawWaterType.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id
            // 设置类型字段
            tdRawWaterType.setType("syas");  // 根据需要设置类型
            //存对象进集合
            depositTdRawWaterType(tdRawWaterType);

            // 34-49列的字段，类型为 qtfs
            for ( j = 34; j <= 49; j++) {
                Object value = row.get(String.valueOf(j));

                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet1表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段（如果有对应字段）
                // 以下为示例，需根据实际需求调整字段名
                if (j == 34) tdRawWaterType.setPH((BigDecimal) value);  // 示例，可以根据需求进行修改
                if (j == 35) tdRawWaterType.setSS((BigDecimal) value);  // 示例
                if (j == 36) tdRawWaterType.setNh3N((BigDecimal) value);  // 示例
                if (j == 37) tdRawWaterType.setTN((BigDecimal) value);  // 示例
                if (j == 38) tdRawWaterType.setCOD((BigDecimal) value);  // 示例
                if (j == 39) tdRawWaterType.setBOD((BigDecimal) value);  // 示例
                if (j == 40) tdRawWaterType.setThiocyanate((BigDecimal) value);  // 示例
                if (j == 41) tdRawWaterType.setSulfide((BigDecimal) value);  // 示例
                if (j == 42) tdRawWaterType.setVolatilePhenols((BigDecimal) value);  // 示例
                if (j == 43) tdRawWaterType.setALK((BigDecimal) value);  // 示例
                if (j == 44) tdRawWaterType.setCI((BigDecimal) value);  // 示例
                if (j == 45) tdRawWaterType.setPetroleum((BigDecimal) value);  // 示例
                if (j == 46) tdRawWaterType.setBenzene((BigDecimal) value);  // 示例
                if (j == 47) tdRawWaterType.setPAH((BigDecimal) value);  // 示例
                if (j == 48) tdRawWaterType.setBaP((BigDecimal) value);  // 示例
                if (j == 49) tdRawWaterType.setTC((BigDecimal) value);  // 示例

            }

            // 使用 UUID 生成唯一的 id
            id = IdUtil.getSnowflakeNextId();;

            // 设置 id 和 rawWaterId
            tdRawWaterType.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id

            // 设置类型字段
            tdRawWaterType.setType("qtfs");  // 根据需要设置类型
            //存对象进集合
            depositTdRawWaterType(tdRawWaterType);

            tdRawWater.setId(rawWaterId);
            depositTdRawWater(tdRawWater);

        }
        if(flag==false){
            errorMessage = "原料水监测表时间不连续";
            errorList.add(errorMessage);
        }
        dateSet.add(excelDate);
    }

    //解析过程数据，第二张表
    private void parsingTdProcessDataType(List<LinkedHashMap> maps) {
        MyDateUtil dateUtil = new MyDateUtil();
        String errorMessage = null;//错误信息
        String excelDate = "";
        int j;
        String[] clo = {"2","3","4","5","6","7","8","9","10","11","12","13","14","15",
                "16","17","18","19","20","21","22","23","24","25","26","27","28",
                "29","30","31","32","33","50","55","56","57","58","65","66","67","78","79","80"};//非空列的数组
        boolean index ;//判断索引
        for (int i = 3; i < maps.size(); i++){
            LinkedHashMap<String, Object> row = maps.get(i);
            TdProcessData tdProcessData = new TdProcessData();
            tdProcessData.setProjectId(pId);
            // 获取时间和日期字段（假设时间在 "1" 位置，日期在 "0" 位置）
            Object time = row.get("1");  // 时间字段
            Object date = row.get("0");  // 日期字段
            // 如果时间或日期为空，跳过该行
            if (time == null || date == null) {
                continue;
            }
            // 格式化日期和时间
            String formattedDateTime =dateUtil.getCurrentDate(date,time);
            // 将 LocalDateTime 转换为 Timestamp
            Timestamp timestamp = Timestamp.valueOf(formattedDateTime);
            String forDateTime = dateUtil.getDate(date);
            excelDate = excelDate + forDateTime;

            tdProcessData.setRecordTime(timestamp);
            for (String j1:clo) {
                index=row.containsKey(j1);
                if(index==false){
                    errorMessage="sheet2表第"+(i+2)+"行第"+(j1+1)+"列有空值";
                    errorList.add(errorMessage);
                }
            }
            TdProcessDataType tdProcessDataType = new TdProcessDataType();
            // 2-17列的字段，类型为 COD
            for ( j = 2; j <= 17; j++) {

                Object value = row.get(String.valueOf(j));

                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 2) tdProcessDataType.setRegulatingPool((BigDecimal) value);  // 设置
                if (j == 3) tdProcessDataType.setPreExposure((BigDecimal) value);  // 设置
                if (j == 4) tdProcessDataType.setPrimarySettlingTank((BigDecimal) value);  // 设置
                if (j == 5) tdProcessDataType.setAnaerobicTankA((BigDecimal) value);  // 设置
                if (j == 6) tdProcessDataType.setAnaerobicTankB((BigDecimal) value);  // 设置
                if (j == 7) tdProcessDataType.setAnoxicTankOneA((BigDecimal) value);  // 设置
                if (j == 8) tdProcessDataType.setAnoxicTankOneB((BigDecimal) value);  // 设置
                if (j == 9) tdProcessDataType.setAerobicTankOneA((BigDecimal) value);  // 设置
                if (j == 10) tdProcessDataType.setAerobicTankOneB((BigDecimal) value);  // 设置
                if (j == 11) tdProcessDataType.setAnoxicTankTwoA((BigDecimal) value);  // 设置
                if (j == 12) tdProcessDataType.setAnoxicTankTwoB((BigDecimal) value);  // 设置
                if (j == 13) tdProcessDataType.setAerobicTankTwoA((BigDecimal) value);  // 设置
                if (j == 14) tdProcessDataType.setAerobicTankTwoB((BigDecimal) value);  // 设置
                if (j == 15) tdProcessDataType.setSstOneA((BigDecimal) value);  // 设置
                if (j == 16) tdProcessDataType.setSstOneB((BigDecimal) value);  // 设置
                if (j == 17) tdProcessDataType.setCoagulationTank((BigDecimal) value);  // 设置

            }

            // 使用 UUID 生成唯一的 id
            long id = IdUtil.getSnowflakeNextId();
            long processDataId = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdProcessDataType.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id
            tdProcessDataType.setProcessDataId(processDataId);  // 同样处理 rawWaterId

            // 设置类型字段
            tdProcessDataType.setType("COD");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType);

            // 18-33列的字段，类型为 NH3_N
            for ( j = 18; j <= 33; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 18) tdProcessDataType.setRegulatingPool((BigDecimal) value);  // 设置
                if (j == 19) tdProcessDataType.setPreExposure((BigDecimal) value);  // 设置
                if (j == 20) tdProcessDataType.setPrimarySettlingTank((BigDecimal) value);  // 设置
                if (j == 21) tdProcessDataType.setAnaerobicTankA((BigDecimal) value);  // 设置
                if (j == 22) tdProcessDataType.setAnaerobicTankB((BigDecimal) value);  // 设置
                if (j == 23) tdProcessDataType.setAnoxicTankOneA((BigDecimal) value);  // 设置
                if (j == 24) tdProcessDataType.setAnoxicTankOneB((BigDecimal) value);  // 设置
                if (j == 25) tdProcessDataType.setAerobicTankOneA((BigDecimal) value);  // 设置
                if (j == 26) tdProcessDataType.setAerobicTankOneB((BigDecimal) value);  // 设置
                if (j == 27) tdProcessDataType.setAnoxicTankTwoA((BigDecimal) value);  // 设置
                if (j == 28) tdProcessDataType.setAnoxicTankTwoB((BigDecimal) value);  // 设置
                if (j == 29) tdProcessDataType.setAerobicTankTwoA((BigDecimal) value);  // 设置
                if (j == 30) tdProcessDataType.setAerobicTankTwoB((BigDecimal) value);  // 设置
                if (j == 31) tdProcessDataType.setSstOneA((BigDecimal) value);  // 设置
                if (j == 32) tdProcessDataType.setSstOneB((BigDecimal) value);  // 设置
                if (j == 33) tdProcessDataType.setCoagulationTank((BigDecimal) value);  // 设置

            }

            // 使用 雪花id 生成唯一的 id
             id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdProcessDataType.setId(id);  // 设置id
            tdProcessDataType.setProcessDataId(processDataId);  // 同样处理 rawWaterId

            // 设置类型字段
            tdProcessDataType.setType("NH3_N");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType);

            // 34-43列的字段，类型为 thiocyanate硫氰酸根
            for ( j = 34; j <= 49; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+1)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 34) tdProcessDataType.setRegulatingPool((BigDecimal) value);  // 设置
                if (j == 35) tdProcessDataType.setPreExposure((BigDecimal) value);  // 设置
                if (j == 36) tdProcessDataType.setPrimarySettlingTank((BigDecimal) value);  // 设置
                if (j == 37) tdProcessDataType.setAnaerobicTankA((BigDecimal) value);  // 设置
                if (j == 38) tdProcessDataType.setAnaerobicTankB((BigDecimal) value);  // 设置
                if (j == 39) tdProcessDataType.setAnoxicTankOneA((BigDecimal) value);  // 设置
                if (j == 40) tdProcessDataType.setAnoxicTankOneB((BigDecimal) value);  // 设置
                if (j == 41) tdProcessDataType.setAerobicTankOneA((BigDecimal) value);  // 设置
                if (j == 42) tdProcessDataType.setAerobicTankOneB((BigDecimal) value);  // 设置
                if (j == 43) tdProcessDataType.setAnoxicTankTwoA((BigDecimal) value);  // 设置
                if (j == 44) tdProcessDataType.setAnoxicTankTwoB((BigDecimal) value);  // 设置
                if (j == 45) tdProcessDataType.setAerobicTankTwoA((BigDecimal) value);  // 设置
                if (j == 46) tdProcessDataType.setAerobicTankTwoB((BigDecimal) value);  // 设置
                if (j == 47) tdProcessDataType.setSstOneA((BigDecimal) value);  // 设置
                if (j == 48) tdProcessDataType.setSstOneB((BigDecimal) value);  // 设置
                if (j == 49) tdProcessDataType.setCoagulationTank((BigDecimal) value);  // 设置

            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdProcessDataType.setId(id);  // 设置id
            tdProcessDataType.setProcessDataId(processDataId);  // 同样处理

            // 设置类型字段
            tdProcessDataType.setType("thiocyanate");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType);

            // 50-65列的字段，类型为PH
            for ( j = 50; j <= 65; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 50) tdProcessDataType.setRegulatingPool((BigDecimal) value);  // 设置调节池
                if (j == 51) tdProcessDataType.setPreExposure((BigDecimal) value);  // 设置预曝器
                if (j == 52) tdProcessDataType.setPrimarySettlingTank((BigDecimal) value);  // 设置初沉池
                if (j == 53) tdProcessDataType.setAnaerobicTankA((BigDecimal) value);  // 设置厌氧池A
                if (j == 54) tdProcessDataType.setAnaerobicTankB((BigDecimal) value);  // 设置厌氧池B
                if (j == 55) tdProcessDataType.setAnoxicTankOneA((BigDecimal) value);  // 设置一级缺氧池A
                if (j == 56) tdProcessDataType.setAnoxicTankOneB((BigDecimal) value);  // 设置一级缺氧池B
                if (j == 57) tdProcessDataType.setAerobicTankOneA((BigDecimal) value);  // 设置一级好氧池A
                if (j == 58) tdProcessDataType.setAerobicTankOneB((BigDecimal) value);  // 设置一级好氧池B
                if (j == 59) tdProcessDataType.setAnoxicTankTwoA((BigDecimal) value);  // 设置二级缺氧池A
                if (j == 60) tdProcessDataType.setAnoxicTankTwoB((BigDecimal) value);  // 设置二级缺氧池B
                if (j == 61) tdProcessDataType.setAerobicTankTwoA((BigDecimal) value);  // 设置二级好氧池A
                if (j == 62) tdProcessDataType.setAerobicTankTwoB((BigDecimal) value);  // 设置二级好氧池B
                if (j == 63) tdProcessDataType.setSstOneA((BigDecimal) value);  // 设置二沉池A
                if (j == 64) tdProcessDataType.setSstOneB((BigDecimal) value);  // 设置二沉池B
                if (j == 65) tdProcessDataType.setCoagulationTank((BigDecimal) value);  // 设置混凝池

            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdProcessDataType.setId(id);  // 设置id
            tdProcessDataType.setProcessDataId(processDataId);  // 同样处理

            // 设置类型字段
            tdProcessDataType.setType("PH");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType);

            TdProcessDataType tdProcessDataType1 = new TdProcessDataType();
            // 66-69列的字段，类型为NO2
            for ( j = 66; j <= 69; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 66) tdProcessDataType1.setSstOneA((BigDecimal) value);  // 设置二沉池A
                if (j == 67) tdProcessDataType1.setSstOneB((BigDecimal) value);  // 设置二沉池B
                if (j == 68) tdProcessDataType1.setSstTwoA((BigDecimal) value);  // 设置二级二沉池A
                if (j == 69) tdProcessDataType1.setSstTwoB((BigDecimal) value); // 设置二级二沉池B

            }

            // 使用 UUID 生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 rawWaterId
            tdProcessDataType1.setId(id);  // 设置id
            tdProcessDataType1.setProcessDataId(processDataId);  // 同样处理

            // 设置类型字段
            tdProcessDataType1.setType("NO2");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType1);

            TdProcessDataType tdProcessDataType2 = new TdProcessDataType();
            // 70-73列的字段，类型为NO3
            for ( j = 70; j <= 73; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 70) tdProcessDataType2.setSstOneA((BigDecimal) value);  // 设置二沉池A
                if (j == 71) tdProcessDataType2.setSstOneB((BigDecimal) value);  // 设置二沉池B
                if (j == 72) tdProcessDataType2.setSstTwoA((BigDecimal) value);  // 设置二级二沉池A
                if (j == 73) tdProcessDataType2.setSstTwoB((BigDecimal) value); // 设置二级二沉池B

            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 ProcessDataId
            tdProcessDataType2.setId(id);  // 设置id
            tdProcessDataType2.setProcessDataId(processDataId);  // 同样处理 ProcessDataId

            // 设置类型字段
            tdProcessDataType2.setType("NO3");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType2);

            TdProcessDataType tdProcessDataType3 = new TdProcessDataType();
            // 74-75列的字段，类型为TP
            for ( j = 74; j <= 75; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 74) tdProcessDataType3.setSstOneA((BigDecimal) value);  // 设置二沉池A
                if (j == 75) tdProcessDataType3.setSstOneB((BigDecimal) value);  // 设置二沉池B

            }
            // 使用 UUID 生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 ProcessDataId
            tdProcessDataType3.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id
            tdProcessDataType3.setProcessDataId(processDataId);  // 同样处理 ProcessDataId

            // 设置类型字段
            tdProcessDataType3.setType("TP");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType3);

            TdProcessDataType tdProcessDataType4 = new TdProcessDataType();
            // 76-77列的字段，类型为TC
            for ( j = 76; j <= 77; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 76) tdProcessDataType4.setSstOneA((BigDecimal) value);  // 设置二沉池A
                if (j == 77) tdProcessDataType4.setSstOneB((BigDecimal) value);  // 设置二沉池B

            }
            // 使用 UUID 生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 ProcessDataId
            tdProcessDataType4.setId(id);  // 使用 UUID 的前 16 个字符作为 Long 类型 id
            tdProcessDataType4.setProcessDataId(processDataId);  // 同样处理 ProcessDataId

            // 设置类型字段
            tdProcessDataType4.setType("TC");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType4);

            TdProcessDataType tdProcessDataType5 = new TdProcessDataType();
            // 78-82列的字段，类型为ALK
            for ( j = 78; j <= 82; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 78) tdProcessDataType5.setRegulatingPool((BigDecimal) value);  // 设置调节池
                if (j == 79) tdProcessDataType5.setAerobicTankOneA((BigDecimal) value);  // 设置一级好氧池A
                if (j == 80) tdProcessDataType5.setAerobicTankOneB((BigDecimal) value);  // 设置一级好氧池B
                if (j == 81) tdProcessDataType5.setAerobicTankTwoA((BigDecimal) value);  // 设置二级好氧池A
                if (j == 82) tdProcessDataType5.setAerobicTankTwoB((BigDecimal) value);  // 设置二级好氧池B

            }
            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 ProcessDataId
            tdProcessDataType5.setId(id);  // 设置id
            tdProcessDataType5.setProcessDataId(processDataId);  // 同样处理 ProcessDataId

            // 设置类型字段
            tdProcessDataType5.setType("ALK");  // 根据需要设置类型
            //存对象进集合
            depositTdProcessDataType(tdProcessDataType5);


            // 83-98列的字段
            for ( j = 83; j <= 98; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet2表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 83) tdProcessData.setCOD((BigDecimal) value);  // 设置COD
                if (j == 84) tdProcessData.setNH3N((BigDecimal) value);  // 设置氨氮
                if (j == 85) tdProcessData.setPH((BigDecimal) value);  // 设置PH
                if (j == 86) tdProcessData.setSulfide((BigDecimal) value);  // 设置硫化物
                if (j == 87) tdProcessData.setVolatilePhenols((BigDecimal) value);  // 设置挥发酚
                if (j == 88) tdProcessData.setCyanide((BigDecimal) value); // 设置氰化物
                if (j == 89) tdProcessData.setTN((BigDecimal) value); // 设置总氮
                if (j == 90) tdProcessData.setTP((BigDecimal) value); // 设置总磷
                if (j == 91) tdProcessData.setPAH((BigDecimal) value); // 设置多环芳烃
                if (j == 92) tdProcessData.setBaP((BigDecimal) value); // 设置苯并
                if (j == 93) tdProcessData.setBOD((BigDecimal) value); // 设置BOD
                if (j == 94) tdProcessData.setPetroleum((BigDecimal) value); // 设置石油类
                if (j == 95) tdProcessData.setSS((BigDecimal) value); // 设置悬浮物
                if (j == 96) tdProcessData.setBenzene((BigDecimal) value); // 设置苯
                if (j == 97) tdProcessData.setNaphthalene((BigDecimal) value); // 设置萘
                if (j == 98) tdProcessData.setChroma((BigDecimal) value); // 设置色度

            }
            tdProcessData.setId(processDataId);  // 同样处理 ProcessDataId

            //存对象进集合
            depositTdProcessData(tdProcessData);
        }
        dateSet.add(excelDate);
    }
    //解析第三张sheet表，工艺参数表
    private void parsingTdOperatingParamsType(List<LinkedHashMap> maps) {
        MyDateUtil dateUtil = new MyDateUtil();
        String errorMessage = null;//错误信息
        String excelDate = "";
        int j;
        String[] clo = {"6","7","15","20","21","22","23","28","29","30","31","36","37","38","39","44","45",
        "46","47","52","53"};//非空列的数组
        boolean index ;//判断索引
        for(int i = 3; i < maps.size(); i++){
            LinkedHashMap<String, Object> row = maps.get(i);
            TdOperatingParams tdOperatingParams =new TdOperatingParams();
            tdOperatingParams.setProjectId(pId);
            // 获取时间和日期字段（假设时间在 "1" 位置，日期在 "0" 位置）
            Object time = row.get("1");  // 时间字段
            Object date = row.get("0");  // 日期字段
            // 如果时间或日期为空，跳过该行
            if (time == null || date == null) {
                continue;
            }
            // 格式化日期和时间
            String formattedDateTime =dateUtil.getCurrentDate(date,time);
            // 将 LocalDateTime 转换为 Timestamp
            Timestamp timestamp = Timestamp.valueOf(formattedDateTime);
            //获取表3时间
            String forDateTime = dateUtil.getDate(date);
            excelDate = excelDate + forDateTime;

            tdOperatingParams.setRecordTime(timestamp);
            for (String j1:clo) {
                index=row.containsKey(j1);
                if(index==false){
                    errorMessage="sheet3表第"+(i+2)+"行第"+(j1+1)+"列有空值";
                    errorList.add(errorMessage);
                }
            }

            TdOperatingParamsType tdOperatingParamsType = new TdOperatingParamsType();
            // 2-17列的字段，类型为 flow
            for ( j = 2; j <= 14; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 2) tdOperatingParamsType.setSurplusAmmoniaWater((BigDecimal) value);  // 设置剩余氨水
                if (j == 3) tdOperatingParamsType.setSteamedAmmoniaWastewater((BigDecimal) value);  // 设置蒸氨废水
                if (j == 4) tdOperatingParamsType.setOtherWastewater((BigDecimal) value);  // 设置其他废水
                if (j == 5) tdOperatingParamsType.setDilutionWater((BigDecimal) value);  // 设置稀释水
                if (j == 6) tdOperatingParamsType.setBiochemicalWaterA((BigDecimal) value);  // 设置生化进水A
                if (j == 7) tdOperatingParamsType.setBiochemicalWaterB((BigDecimal) value);  // 设置生化进水B
                if (j == 8) tdOperatingParamsType.setNitrationRefluxOneA((BigDecimal) value);  // 设置一级硝化液回流A
                if (j == 9) tdOperatingParamsType.setNitrationRefluxOneB((BigDecimal) value);  // 设置一级硝化液回流B
                if (j == 10) tdOperatingParamsType.setSludgeReturnOneA((BigDecimal) value);  // 设置一级污泥回流A
                if (j == 11) tdOperatingParamsType.setSludgeReturnOneB((BigDecimal) value);  // 设置一级污泥回流B
                if (j == 12) tdOperatingParamsType.setSludgeReturnTwoA((BigDecimal) value);  // 设置二级污泥回流A
                if (j == 13) tdOperatingParamsType.setSludgeReturnTwoB((BigDecimal) value);  // 设置二级污泥回流B
                if (j == 14) tdOperatingParamsType.setFinalEffluent((BigDecimal) value); //设置最终出水
            }

            // 使用雪花id生成唯一的 id
            long id = IdUtil.getSnowflakeNextId();
            long operatinParamsId = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType.setId(id);  // 设置id
            tdOperatingParamsType.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            tdOperatingParams.setId(operatinParamsId);

            depositTdOperatingParams(tdOperatingParams);

            // 设置类型字段
            tdOperatingParamsType.setType("flow");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType);

            TdOperatingParamsType tdOperatingParamsType1 = new TdOperatingParamsType();
            // 15-27列的字段，类型为 temperature
            for ( j = 15; j <= 27; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 15) tdOperatingParamsType1.setRegulatingPool((BigDecimal) value);  // 设置剩余氨水
                if (j == 16) tdOperatingParamsType1.setPreExposure((BigDecimal) value);  // 设置蒸氨废水
                if (j == 17) tdOperatingParamsType1.setPrimarySettlingTank((BigDecimal) value);  // 设置其他废水
                if (j == 18) tdOperatingParamsType1.setAnaerobicTankA((BigDecimal) value);  // 设置厌氧池A
                if (j == 19) tdOperatingParamsType1.setAnaerobicTankB((BigDecimal) value); // 设置厌氧池B
                if (j == 20) tdOperatingParamsType1.setAnoxicTankOneA((BigDecimal) value); // 设置一级缺氧池A
                if (j == 21) tdOperatingParamsType1.setAnoxicTankOneB((BigDecimal) value); // 设置一级缺氧池B
                if (j == 22) tdOperatingParamsType1.setAerobicTankOneA((BigDecimal) value); // 设置一级好氧池A
                if (j == 23) tdOperatingParamsType1.setAerobicTankOneB((BigDecimal) value); // 设置一级好氧池B
                if (j == 24) tdOperatingParamsType1.setAnoxicTankTwoA((BigDecimal) value); // 设置二级缺氧池A
                if (j == 25) tdOperatingParamsType1.setAnoxicTankTwoB((BigDecimal) value); // 设置二级缺氧池B
                if (j == 26) tdOperatingParamsType1.setAerobicTankTwoA((BigDecimal) value); // 设置二级好氧池A
                if (j == 27) tdOperatingParamsType1.setAerobicTankTwoB((BigDecimal) value); // 设置二级好氧池B
            }

            // 使用雪花id生成唯一的 id
           id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType1.setId(id);  // 设置id
            tdOperatingParamsType1.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            // 设置类型字段
            tdOperatingParamsType1.setType("temperature");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType1);

            TdOperatingParamsType tdOperatingParamsType2 = new TdOperatingParamsType();
            // 28-35列的字段，类型为 dissolvedO
            for ( j = 28; j <= 35; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 28) tdOperatingParamsType2.setAnoxicTankOneA((BigDecimal) value); // 设置一级缺氧池A
                if (j == 29) tdOperatingParamsType2.setAnoxicTankOneB((BigDecimal) value); // 设置一级缺氧池B
                if (j == 30) tdOperatingParamsType2.setAerobicTankOneA((BigDecimal) value); // 设置一级好氧池A
                if (j == 31) tdOperatingParamsType2.setAerobicTankOneB((BigDecimal) value); // 设置一级好氧池B
                if (j == 32) tdOperatingParamsType2.setAnoxicTankTwoA((BigDecimal) value); // 设置二级缺氧池A
                if (j == 33) tdOperatingParamsType2.setAnoxicTankTwoB((BigDecimal) value); // 设置二级缺氧池B
                if (j == 34) tdOperatingParamsType2.setAerobicTankTwoA((BigDecimal) value); // 设置二级好氧池A
                if (j == 35) tdOperatingParamsType2.setAerobicTankTwoB((BigDecimal) value); // 设置二级好氧池B
            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType2.setId(id);  // 设置id
            tdOperatingParamsType2.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            // 设置类型字段
            tdOperatingParamsType2.setType("dissolvedO");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType2);

            TdOperatingParamsType tdOperatingParamsType3 = new TdOperatingParamsType();
            // 36-43列的字段，类型为 sludge
            for ( j = 36; j <= 43; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 36) tdOperatingParamsType3.setAerobicTankOneA((BigDecimal) value); // 设置一级好氧池A
                if (j == 37) tdOperatingParamsType3.setAerobicTankOneB((BigDecimal) value); // 设置一级好氧池B
                if (j == 38) tdOperatingParamsType3.setSludgeReturnOneA((BigDecimal) value); // 设置一级污泥回流A
                if (j == 39) tdOperatingParamsType3.setSludgeReturnOneB((BigDecimal) value); // 设置一级污泥回流B
                if (j == 40) tdOperatingParamsType3.setAerobicTankTwoA((BigDecimal) value); // 设置二级好氧池A
                if (j == 41) tdOperatingParamsType3.setAerobicTankTwoB((BigDecimal) value); // 设置二级好氧池B
                if (j == 42) tdOperatingParamsType3.setSludgeReturnTwoA((BigDecimal) value); // 设置二级污泥回流A
                if (j == 43) tdOperatingParamsType3.setSludgeReturnTwoB((BigDecimal) value); // 设置二级污泥回流B
            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType3.setId(id);  // 设置id
            tdOperatingParamsType3.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            // 设置类型字段
            tdOperatingParamsType3.setType("sludge");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType3);

            TdOperatingParamsType tdOperatingParamsType4 = new TdOperatingParamsType();
            // 44-51列的字段，类型为 SV30
            for ( j = 44; j <= 51; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 44) tdOperatingParamsType4.setAerobicTankOneA((BigDecimal) value); // 设置一级好氧池A
                if (j == 45) tdOperatingParamsType4.setAerobicTankOneB((BigDecimal) value); // 设置一级好氧池B
                if (j == 46) tdOperatingParamsType4.setSludgeReturnOneA((BigDecimal) value); // 设置一级污泥回流A
                if (j == 47) tdOperatingParamsType4.setSludgeReturnOneB((BigDecimal) value); // 设置一级污泥回流B
                if (j == 48) tdOperatingParamsType4.setAerobicTankTwoA((BigDecimal) value); // 设置二级好氧池A
                if (j == 49) tdOperatingParamsType4.setAerobicTankTwoB((BigDecimal) value); // 设置二级好氧池B
                if (j == 50) tdOperatingParamsType4.setSludgeReturnTwoA((BigDecimal) value); // 设置二级污泥回流A
                if (j == 51) tdOperatingParamsType4.setSludgeReturnTwoB((BigDecimal) value); // 设置二级污泥回流B
            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType4.setId(id);  // 设置id
            tdOperatingParamsType4.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            // 设置类型字段
            tdOperatingParamsType4.setType("SV30");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType4);

            TdOperatingParamsType tdOperatingParamsType5 = new TdOperatingParamsType();
            // 52-55列的字段，类型为 excessSludge
            for ( j = 52; j <= 55; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "sheet3表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 52) tdOperatingParamsType5.setSstOneA((BigDecimal) value); // 设置一级二沉池A
                if (j == 53) tdOperatingParamsType5.setSstOneB((BigDecimal) value); // 设置一级二沉池B
                if (j == 54) tdOperatingParamsType5.setSstTwoA((BigDecimal) value); // 设置二级二沉池A
                if (j == 55) tdOperatingParamsType5.setSstTwoB((BigDecimal) value); // 设置二级二沉池B
            }

            // 使用雪花id生成唯一的 id
            id = IdUtil.getSnowflakeNextId();

            // 设置 id 和 operatinParamsId
            tdOperatingParamsType5.setId(id);  // 设置id
            tdOperatingParamsType5.setOperatinParamsId(operatinParamsId);  // 同样处理 operatinParamsId

            // 设置类型字段
            tdOperatingParamsType5.setType("excessSludge");  // 根据需要设置类型
            //存对象进集合
            depositTdOperatingParamsType(tdOperatingParamsType5);
        }
        dateSet.add(excelDate);
    }
    //解析第四张sheet表，
    private void parsingTdProductionData(List<LinkedHashMap> maps) {
        MyDateUtil dateUtil = new MyDateUtil();
        String errorMessage = null;//错误信息
        String excelDate = "";
        int j;
        String[] clo = {"1","2","3","4","5","6","7","8","9"};//非空列的数组
        boolean index ;//判断索引
        for (int i = 2; i < maps.size(); i++) {
            LinkedHashMap<String, Object> row = maps.get(i);
            TdProductionData tdProductionData = new TdProductionData();
            tdProductionData.setProjectId(pId);
            // 获取时间和日期字段（假设时间在 "1" 位置，日期在 "0" 位置）
            Object date = row.get("0");  // 日期字段
            // 如果时间或日期为空，跳过该行
            if ( date == null) {
                continue;
            }
            // 格式化日期和时间
            String formattedDateTime =dateUtil.getDate(date);
            // 将 LocalDateTime 转换为 Timestamp
            Timestamp timestamp = Timestamp.valueOf(formattedDateTime);
            excelDate = excelDate + formattedDateTime;

            tdProductionData.setRecordTime(timestamp);

            for (String j1:clo) {
                index=row.containsKey(j1);
                if(index==false){
                    errorMessage="生产数据表第"+(i+2)+"行第"+(j1+1)+"列有空值";
                    errorList.add(errorMessage);
                }
            }
            // 1-41列的字段
            for ( j = 1; j <= 41; j++) {
                Object value = row.get(String.valueOf(j));
                // 确保值是 BigDecimal 类型或者可以转换为 BigDecimal
                if (value != null && j!=7 && j!=8 && j!=9) {
                    try {
                        if (value instanceof String) {
                            // 如果是字符串，尝试转换为 BigDecimal
                            value = new BigDecimal((String) value);
                        } else if (!(value instanceof BigDecimal)) {
                            // 如果不是 BigDecimal，则跳过
                            continue;
                        }
                    } catch (NumberFormatException e) {
                        errorMessage = "生产数据表第"+(i+2)+"行第"+(j+1)+"列有非法字符";
                        errorList.add(errorMessage);
                        // 如果转换失败，跳过该字段
                        continue;
                    }
                }

                // 根据列的不同赋值给具体的字段
                if (j == 1) tdProductionData.setTreatmentWater((BigDecimal) value);  // 设置处理水量
                if (j == 2) tdProductionData.setLaborCost((BigDecimal) value);  // 设置人工费用
                if (j == 3) tdProductionData.setRepairCost((BigDecimal) value);  // 设置维修费用
                if (j == 4) tdProductionData.setOtherCost((BigDecimal) value); // 设置其他费用
                if (j == 5) tdProductionData.setMedicCost((BigDecimal) value); //设置药物费用
                if (j == 6) tdProductionData.setDailyInterestRate((BigDecimal) value); // 设置日利润
                if (j == 7) tdProductionData.setExplainingLargeExpenses((String) value); // 设置解释大费用
                if (j == 8) tdProductionData.setAbnormalProduction((String) value); // 设置异常生产
                if (j == 9) tdProductionData.setKeyWorkReport((String) value); // 设置关键工作报告
                if (j == 10) tdProductionData.setSodiumDihydrogenPhosphate((BigDecimal) value); // 设置Na2HPO4
                if (j == 11) tdProductionData.setGlucose((BigDecimal) value); // 设置葡萄糖
                if (j == 12) tdProductionData.setBioactivePhosphorus((BigDecimal) value); // 设置生物磷
                if (j == 13) tdProductionData.setDefoamer((BigDecimal) value); // 设置消泡剂
                if (j == 14) tdProductionData.setLiquidSodiumAcetate((BigDecimal) value); // 设置液体乙酸钠
                if (j == 15) tdProductionData.setCompositeCarbonSource((BigDecimal) value); // 设置复合碳源
                if (j == 16) tdProductionData.setCompoundAlkali((BigDecimal) value); // 设置复合碱
                if (j == 17) tdProductionData.setFerrousSulfate((BigDecimal) value); //设置硫酸亚铁
                if (j == 18) tdProductionData.setLiquidBase((BigDecimal) value); // 设置液碱
                if (j == 19) tdProductionData.setSodaAsh((BigDecimal) value); //设置纯碱
                if (j == 20) tdProductionData.setDs821((BigDecimal) value); // 设置DS821
                if (j == 21) tdProductionData.setDs882((BigDecimal) value); // 设置DS882
                if (j == 22) tdProductionData.setSodiumHypochlorite((BigDecimal) value); //设置次氯酸钠
                if (j == 23) tdProductionData.setDs6031Liquid((BigDecimal) value); //设置DS6031液
                if (j == 24) tdProductionData.setDs6031Solid((BigDecimal) value); // 设置DS6031固
                if (j == 25) tdProductionData.setDs832((BigDecimal) value); // 设置DS832
                if (j == 26) tdProductionData.setDs7021((BigDecimal) value); // 设置DS7021
                if (j == 27) tdProductionData.setDs8031((BigDecimal) value); // 设置DS8031
                if (j == 28) tdProductionData.setSulfuricAcid((BigDecimal) value); // 设置硫酸
                if (j == 29) tdProductionData.setDs722((BigDecimal) value); // 设置Ds722
                if (j == 30) tdProductionData.setLiquidAlkali32((BigDecimal) value); // 设置液碱32%
                if (j == 31) tdProductionData.setLiquidAlkali10((BigDecimal) value); // 设置液碱10%
                if (j == 32) tdProductionData.setPieceAlkali((BigDecimal) value); // 设置片碱
                if (j == 33) tdProductionData.setCorrosionInhibitor((BigDecimal) value); // 设置低磷阻垢缓蚀剂
                if (j == 34) tdProductionData.setCitricAcid((BigDecimal) value); // 设置柠檬酸
                if (j == 35) tdProductionData.setHydratedLime((BigDecimal) value); // 设置熟石灰
                if (j == 36) tdProductionData.setQuickLime((BigDecimal) value); // 设置生石灰
                if (j == 37) tdProductionData.setPowder((BigDecimal) value); // 设置次粉
                if (j == 38) tdProductionData.setNonOxidizingFungicide((BigDecimal) value); // 设置非氧化杀菌剂
                if (j == 39) tdProductionData.setReducingAgent((BigDecimal) value); // 设置还原剂
                if (j == 40) tdProductionData.setEdtaFourSodium((BigDecimal) value); // 设置EDTA-四钠
                if (j == 41) tdProductionData.setHydrochloricAcid((BigDecimal) value); // 设置盐酸
            }

            // 使用雪花id生成唯一的 id
            long id = IdUtil.getSnowflakeNextId();

            // 设置 id
            tdProductionData.setId(id);  // 设置id

            //存对象进集合
            depositTdProductionData(tdProductionData);
        }
        dateSet.add(excelDate);
    }
    //放tdOperatingParams进集合
    private void depositTdOperatingParams(TdOperatingParams tdOperatingParams){
        TdOperatingParams tdOperatingParams1 = new TdOperatingParams(tdOperatingParams);
        tdOperatingParamsList.add(tdOperatingParams1);
    }
    //获取tdOperatingParams集合
    private List<TdOperatingParams> getTdOperatingParams( List<TdOperatingParams> tdOperatingParamsList){
        return tdOperatingParamsList;
    }
    //放tdProductionData进集合
    private void depositTdProductionData(TdProductionData tdProductionData) {
        TdProductionData tdProductionData1 = new TdProductionData(tdProductionData);
        tdProductionDataList.add(tdProductionData1);
    }
    //获取tdProductionData集合
    private List<TdProductionData> getTdProductionData( List<TdProductionData> tdProductionDataList){
        return tdProductionDataList;
    }

    //放tdOperatingParamsType进集合
    private void depositTdOperatingParamsType(TdOperatingParamsType tdOperatingParamsType) {
        TdOperatingParamsType tdOperatingParamsType1 = new TdOperatingParamsType(tdOperatingParamsType);
        tdOperatingParamsTypeList.add(tdOperatingParamsType1);
    }
    //获取tdOperatingParamsType集合
    private List<TdOperatingParamsType> getTdOperatingParamsType( List<TdOperatingParamsType> tdOperatingParamsTypeList){
        return tdOperatingParamsTypeList;
    }
    //放tdProcessData进集合
    private void depositTdProcessData(TdProcessData tdProcessData){
        TdProcessData tdProcessData1 = new TdProcessData(tdProcessData);
        tdProcessDataList.add(tdProcessData1);
    }
    //获取tdProcessData集合
    private List<TdProcessData> getTdProcessData( List<TdProcessData> tdProcessDataList){
        return tdProcessDataList;
    }
    //放tdProcessDataType进集合
    private void depositTdProcessDataType(TdProcessDataType tdProcessDataType) {
        TdProcessDataType tdProcessDataType1 = new TdProcessDataType(tdProcessDataType);
        tdProcessDataTypeList.add(tdProcessDataType1);
    }
    //获取tdProcessDataType集合
    private List<TdProcessDataType> getTdProcessDataType( List<TdProcessDataType> tdProcessDataTypeList){
        return tdProcessDataTypeList;
    }

    //校验日期是否连续
    private Boolean depositDate(Date date){
        dateList.add(date);
        int size = dateList.size();
        while (size>1&&size <= dateList.size()){
            Date date1 = dateList.get(size-2);
            Date date2 = dateList.get(size-1);
            long betweenDay = DateUtil.between(date1, date2, DateUnit.DAY);
            if (betweenDay!=1L || date2.before(date1)){
                return false;
            }
            size++;
        }
        return true;
    }
    //放tdRawWaterType进集合
    private void depositTdRawWaterType(TdRawWaterType tdRawWaterType){
        TdRawWaterType tdRawWaterType1 = new TdRawWaterType(tdRawWaterType);

        tdRawWaterTypeList.add(tdRawWaterType1);
    }
    //放tdRawWater进集合
    private void depositTdRawWater(TdRawWater tdRawWater){
        tdRawWaterList.add(tdRawWater);
    }
    //获取tdRawWater集合
    private List<TdRawWater> getTdRawWater( List<TdRawWater> tdRawWaterList){
        return tdRawWaterList;
    }
    //获取tdRawWaterTypeList
    private List<TdRawWaterType> getTdRawWaterTypeList( List<TdRawWaterType> tdRawWaterTypeList){
        return tdRawWaterTypeList;
    }
    //判断四表时间
    private void judgeDateSet(Set<String> dateSet) {
        if (dateSet.size()!=1){
            errorList.add("四张表格时间不一致");
        }
    }
    //导入反馈
    private void extracted() {
        if(errorList==null || errorList.size()==0){
            List<TdRawWaterType> list = getTdRawWaterTypeList(tdRawWaterTypeList);
            List<TdProcessDataType> listTdProcessDataType = getTdProcessDataType(tdProcessDataTypeList);
            List<TdProcessData> listProcessData = getTdProcessData(tdProcessDataList);
            List<TdOperatingParamsType> listOperatingParamsType = getTdOperatingParamsType(tdOperatingParamsTypeList);
            List<TdProductionData> listProductionData = getTdProductionData(tdProductionDataList);
            List<TdOperatingParams> listOperatingParams = getTdOperatingParams(tdOperatingParamsList);
            List<TdRawWater> listRawWater = getTdRawWater(tdRawWaterList);
            System.out.println(projectTimeDto);
            tdRawWaterTypeMapper.deleteRawWaterTypeByTimeRange(projectTimeDto);
            tdRawWaterMapper.deleteRawWaterByTimeRange(projectTimeDto);
            tdOperatingParamsTypeMapper.deleteOperatingParamsTypeByTimeRange(projectTimeDto);
            tdOperatingParamsMapper.deleteOperatingParamsByTimeRange(projectTimeDto);
            tdProcessDataTypeMapper.deleteProcessDataTypeByTimeRange(projectTimeDto);
            tdProcessDataMapper.deleteProcessDataByTimeRange(projectTimeDto);
            tdProductionDataMapper.deleteProductionDataByTimeRange(projectTimeDto);
            for (TdProcessDataType tdProcessDataType:listTdProcessDataType
                 ) {
                tdProcessDataTypeMapper.insertTdProcessDataType(tdProcessDataType);
            }
            for (TdOperatingParamsType tdOperatingParamsType:listOperatingParamsType
                 ) {
                tdOperatingParamsTypeMapper.insertTdOperatingParamsType(tdOperatingParamsType);
            }
            // 可以将数据保存到数据库
            tdRawWaterTypeMapper.batchInsertTdRawWaterType(list);
            tdProcessDataMapper.batchInsertTdProcessData(listProcessData);
            tdProductionDataMapper.batchInsertTdProductionData(listProductionData);
            tdOperatingParamsMapper.batchInsertTdOperatingParams(listOperatingParams);
            tdRawWaterMapper.batchInsertTdRawWater(listRawWater);

            System.out.println("导入成功");
        }else {
            System.out.println(errorList);

        }
    }
    @Override
    public void clearList(){
        tdProcessDataTypeList.clear();
        tdOperatingParamsTypeList.clear();
        tdRawWaterTypeList.clear();
        //存TdRawWaterd的集合
        tdRawWaterList.clear();
        tdProcessDataList.clear();
        //存放tdProductionData的集合
        tdProductionDataList.clear();
        //存放tdOperatingParams的集合
        tdOperatingParamsList.clear();
    }


}
